home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / grafik / raytracing / rayshade-4.0.6.3 / unapplied / multicsg < prev    next >
Encoding:
Text File  |  1994-08-09  |  14.4 KB  |  578 lines
  1.  
  2. Multiple csg objects:
  3. The patches to csg.c and csg.h make it possible to have more than
  4. two objects in a CSG object. This is a little hack.
  5.  
  6. ======================= cut here ========================
  7. *** csg.h.orig    Wed Jun 17 18:06:22 1992
  8. --- csg.h    Wed Jun 17 18:08:38 1992
  9. ***************
  10. *** 34,40 ****
  11.   
  12.   typedef struct Csg {
  13.       char operator;            /* Union, Intersect, or Difference */
  14. !     struct Geom *obj1, *obj2;
  15.       int (*intmeth)();        /* Intersection method. */
  16.       Float bounds[2][3];
  17.   } Csg;
  18. --- 34,41 ----
  19.   
  20.   typedef struct Csg {
  21.       char operator;            /* Union, Intersect, or Difference */
  22. !     struct Geom *list;        /* Csg objects */
  23. !     int nobjs;            /* Number of objects in the list */
  24.       int (*intmeth)();        /* Intersection method. */
  25.       Float bounds[2][3];
  26.   } Csg;
  27. *** csg.c.orig    Wed Jun 17 17:46:54 1992
  28. --- csg.c    Wed Jun 17 18:02:01 1992
  29. ***************
  30. *** 40,46 ****
  31.   
  32.       csg = (Csg *)share_malloc(sizeof(Csg));
  33.       csg->operator = op;
  34. !     csg->obj1 = csg->obj2 = (Geom *)NULL;
  35.   
  36.   
  37.       switch(op) {
  38. --- 40,46 ----
  39.   
  40.       csg = (Csg *)share_malloc(sizeof(Csg));
  41.       csg->operator = op;
  42. !     csg->list = (Geom *)NULL;
  43.   
  44.   
  45.       switch(op) {
  46. ***************
  47. *** 82,123 ****
  48.       return csgName;
  49.   }
  50.   
  51. - csg_intersect_objs(csg, ray, hit1, hit2, mindist, dist1, dist2)
  52. - Csg *csg;
  53. - Ray *ray;
  54. - HitList *hit1, *hit2;
  55. - Float mindist, *dist1, *dist2;
  56. - {
  57. -     int operator;
  58. - 
  59. -     hit1->nodes = 0;
  60. -     hit2->nodes = 0;
  61. -     *dist1 = FAR_AWAY;
  62. -     *dist2 = FAR_AWAY;
  63. -     operator = csg->operator;
  64. - 
  65. -     if (!intersect(csg->obj1, ray, hit1, mindist, dist1) &&
  66. -         ((operator == CSG_INTERSECT) || (operator == CSG_DIFFERENCE))) {
  67. -         /*
  68. -          * Intersection and Difference cases: if you miss the first
  69. -          * object, you missed the whole thing.
  70. -          */
  71. -         return FALSE;
  72. -     }
  73. - 
  74. -     if (!intersect(csg->obj2, ray, hit2, mindist, dist2) &&
  75. -         ((operator == CSG_INTERSECT) ||
  76. -          (hit1->nodes == 0) && (operator == CSG_UNION))) {
  77. -         /*
  78. -          * Intersect case:  if you miss either object, you miss whole
  79. -          * Union case: if you miss both object, you miss whole
  80. -          */
  81. -         return FALSE;
  82. -     }
  83. - 
  84. -     return TRUE;
  85. - }
  86. - 
  87.   int
  88.   csg_enter_obj(hitp)
  89.   HitList *hitp;
  90. --- 82,87 ----
  91. ***************
  92. *** 130,143 ****
  93.   }
  94.   
  95.   static int
  96. ! CsgUnionInt(ray, hit1p, hit2p, dist1, dist2, hitclose, distclose)
  97.   Ray *ray;
  98.   HitList *hit1p, *hit2p, **hitclose;
  99.   Float dist1, dist2, *distclose;
  100.   {
  101. !     Float distnext;
  102.       HitList hitnext, *hittmp;
  103.   
  104.       while (TRUE) {
  105.           if (hit2p->nodes == 0 ||
  106.               csg_enter_obj(hit2p)) {
  107. --- 94,120 ----
  108.   }
  109.   
  110.   static int
  111. ! CsgUnionInt(csg, ray, hit1p, hit2p, dist1, dist2, hitclose, distclose)
  112. ! Csg *csg;
  113.   Ray *ray;
  114.   HitList *hit1p, *hit2p, **hitclose;
  115.   Float dist1, dist2, *distclose;
  116.   {
  117. !     Float disttmp, distnext;
  118.       HitList hitnext, *hittmp;
  119. +     int sect, fl = 0;
  120.   
  121. +     if (dist1 > dist2) {
  122. +         /* swap so 1 is closest */
  123. +         disttmp = dist2;  
  124. +         dist2 = dist1;  
  125. +         dist1 = disttmp;
  126. +         hittmp = hit1p;
  127. +         hit1p = hit2p;
  128. +         hit2p = hittmp;
  129. +         fl = 1;
  130. +     }
  131. + 
  132.       while (TRUE) {
  133.           if (hit2p->nodes == 0 ||
  134.               csg_enter_obj(hit2p)) {
  135. ***************
  136. *** 149,156 ****
  137.           } else {
  138.               distnext = FAR_AWAY;
  139.               hitnext.nodes = 0;
  140. !             if (!intersect(hit1p->data[hit1p->nodes-1].obj,
  141. !                 ray, &hitnext, dist2+EPSILON, &distnext)) {
  142.                   /*
  143.                    * None of obj1 beyond, return hit2 (leaving)
  144.                    */
  145. --- 126,138 ----
  146.           } else {
  147.               distnext = FAR_AWAY;
  148.               hitnext.nodes = 0;
  149. !             if (fl || csg->nobjs == 1)
  150. !                 sect =  intersect(hit1p->data[hit1p->nodes-1].obj,
  151. !                     ray, &hitnext, dist2+EPSILON, &distnext);
  152. !             else
  153. !                 sect =  CsgIntersect(csg,
  154. !                     ray, &hitnext, dist2+EPSILON, &distnext);
  155. !             if (!sect) {
  156.                   /*
  157.                    * None of obj1 beyond, return hit2 (leaving)
  158.                    */
  159. ***************
  160. *** 169,174 ****
  161. --- 151,157 ----
  162.                   dist1 = dist2;
  163.                   CsgHitlistCopy(&hitnext, hit2p);
  164.                   dist2 = distnext;
  165. +                 fl ^= 1;
  166.                   /* and continue */
  167.               }
  168.           }
  169. ***************
  170. *** 176,189 ****
  171.   }
  172.   
  173.   static int
  174. ! CsgIntersectInt(ray, hit1p, hit2p, dist1, dist2, hitclose, distclose)
  175.   Ray *ray;
  176.   HitList *hit1p, *hit2p, **hitclose;
  177.   Float dist1, dist2, *distclose;
  178.   {
  179.       HitList *hittmp, hitnext;
  180. !     Float distnext;
  181.   
  182.       while (TRUE) {
  183.           if (!csg_enter_obj(hit2p)) {
  184.               /* Ray is leaving obj2 */
  185. --- 159,185 ----
  186.   }
  187.   
  188.   static int
  189. ! CsgIntersectInt(csg, ray, hit1p, hit2p, dist1, dist2, hitclose, distclose)
  190. ! Csg *csg;
  191.   Ray *ray;
  192.   HitList *hit1p, *hit2p, **hitclose;
  193.   Float dist1, dist2, *distclose;
  194.   {
  195.       HitList *hittmp, hitnext;
  196. !     Float disttmp, distnext;
  197. !     int sect, fl = 0;
  198.   
  199. +     if (dist1 > dist2) {
  200. +         /* swap so 1 is closest */
  201. +         disttmp = dist2;  
  202. +         dist2 = dist1;  
  203. +         dist1 = disttmp;
  204. +         hittmp = hit1p;
  205. +         hit1p = hit2p;
  206. +         hit2p = hittmp;
  207. +         fl = 1;
  208. +     }
  209. + 
  210.       while (TRUE) {
  211.           if (!csg_enter_obj(hit2p)) {
  212.               /* Ray is leaving obj2 */
  213. ***************
  214. *** 195,202 ****
  215.           } else {
  216.               distnext = FAR_AWAY;
  217.               hitnext.nodes = 0;
  218. !             if (!intersect(hit1p->data[hit1p->nodes-1].obj,
  219. !                 ray, &hitnext, dist2+EPSILON, &distnext)) {
  220.                   /*
  221.                    * None of obj1 beyond, so return miss
  222.                    */
  223. --- 191,203 ----
  224.           } else {
  225.               distnext = FAR_AWAY;
  226.               hitnext.nodes = 0;
  227. !             if (fl || csg->nobjs == 1)
  228. !                 sect =  intersect(hit1p->data[hit1p->nodes-1].obj,
  229. !                     ray, &hitnext, dist2+EPSILON, &distnext);
  230. !             else
  231. !                 sect =  CsgIntersect(csg,
  232. !                     ray, &hitnext, dist2+EPSILON, &distnext);
  233. !             if (!sect) {
  234.                   /*
  235.                    * None of obj1 beyond, so return miss
  236.                    */
  237. ***************
  238. *** 213,218 ****
  239. --- 214,220 ----
  240.                   dist1 = dist2;
  241.                   CsgHitlistCopy(&hitnext, hit2p);
  242.                   dist2 = distnext;
  243. +                 fl ^= 1;
  244.                   /* and continue */
  245.               }
  246.           }
  247. ***************
  248. *** 220,226 ****
  249.   }
  250.   
  251.   static int
  252. ! CsgDifferenceInt(ray, hit1p, hit2p, dist1, dist2, hitclose, distclose)
  253.   Ray *ray;
  254.   HitList *hit1p, *hit2p, **hitclose;
  255.   Float dist1, dist2, *distclose;
  256. --- 222,229 ----
  257.   }
  258.   
  259.   static int
  260. ! CsgDifferenceInt(csg, ray, hit1p, hit2p, dist1, dist2, hitclose, distclose)
  261. ! Csg *csg;
  262.   Ray *ray;
  263.   HitList *hit1p, *hit2p, **hitclose;
  264.   Float dist1, dist2, *distclose;
  265. ***************
  266. *** 227,232 ****
  267. --- 230,236 ----
  268.   {
  269.       Float distnext;
  270.       HitList hitnext;
  271. +     int sect;
  272.   
  273.       while (TRUE) {
  274.           if (dist1 < dist2) {
  275. ***************
  276. *** 240,247 ****
  277.               } else {
  278.                   distnext = FAR_AWAY;
  279.                   hitnext.nodes = 0;
  280. !                 if (!intersect(hit1p->data[hit1p->nodes-1].obj,
  281. !                     ray, &hitnext, dist2+EPSILON, &distnext)) {
  282.                       /*
  283.                        * None of obj1 beyond, so
  284.                        * return miss
  285. --- 244,256 ----
  286.               } else {
  287.                   distnext = FAR_AWAY;
  288.                   hitnext.nodes = 0;
  289. !                 if (csg->nobjs == 1)
  290. !                     sect = intersect(hit1p->data[hit1p->nodes-1].obj,
  291. !                         ray, &hitnext, dist2+EPSILON, &distnext);
  292. !                 else
  293. !                     sect = CsgIntersect(csg,
  294. !                         ray, &hitnext, dist2+EPSILON, &distnext);
  295. !                 if (!sect) {
  296.                       /*
  297.                        * None of obj1 beyond, so
  298.                        * return miss
  299. ***************
  300. *** 298,341 ****
  301.   HitList *hitlist;
  302.   Float mindist, *maxdist;
  303.   {
  304. !     Float dist1, dist2, disttmp, distclose;
  305. !     HitList hit1, hit2, *hit1p, *hit2p, *hitclose;
  306.   
  307. !     hit1p = &hit1;
  308. !     hit2p = &hit2;
  309. !     if (!csg_intersect_objs(csg, ray, hit1p, hit2p, mindist,
  310. !         &dist1, &dist2)) {
  311. !         /* missed the csg object */
  312.           return FALSE;
  313.       }
  314.   
  315. !     if ((dist1 > dist2) &&
  316. !         (csg->operator == CSG_UNION || csg->operator == CSG_INTERSECT)) {
  317. !         /* swap so 1 is closest (except in difference case) */
  318. !         disttmp = dist2;  
  319. !         dist2 = dist1;  
  320. !         dist1 = disttmp;
  321. !         hit1p = &hit2;  
  322. !         hit2p = &hit1;
  323. !     }
  324.   
  325. !     /*
  326. !      * Call appropriate intersection method.  If FALSE is return,
  327. !      * no hit of any kind was found.
  328. !      */
  329. !     if (!(*csg->intmeth)(ray, hit1p, hit2p, dist1, dist2,
  330. !         &hitclose, &distclose))
  331. !         return FALSE;
  332.   
  333. !     /*
  334. !      * At this time, the closest hit is in hitclose and
  335. !      * distclose.
  336. !      */
  337. !     if (distclose < mindist || distclose > *maxdist)
  338.           return FALSE;
  339.   
  340. !     CsgHitlistCopy(hitclose, hitlist);
  341. !     *maxdist = distclose;
  342.       return TRUE;
  343.   }
  344.   
  345. --- 307,384 ----
  346.   HitList *hitlist;
  347.   Float mindist, *maxdist;
  348.   {
  349. !     Float distcsg, distobj, distclose;
  350. !     HitList hit1, hit2, *hitclose, *hitcsgp, *hitobjp;
  351. !     int operator, nobjs;
  352. !     Geom *obj;
  353.   
  354. !     operator = csg->operator;
  355. ! 
  356. !     hitcsgp = &hit1;
  357. !     distcsg = FAR_AWAY;
  358. !     obj = csg->list;
  359. !     hitcsgp->nodes = 0;
  360. !     if (!intersect(obj, ray, hitcsgp, mindist, &distcsg) &&
  361. !         (operator == CSG_INTERSECT || operator == CSG_DIFFERENCE)) {
  362. !         /*
  363. !          * Intersection and Difference cases: if you miss the
  364. !          * first object, you missed the whole thing.
  365. !          */
  366.           return FALSE;
  367.       }
  368.   
  369. !     hitobjp = &hit2;
  370. !     hitclose = &hit1;
  371. !     distclose = distcsg;
  372.   
  373. !         nobjs = csg->nobjs;
  374. !         csg->nobjs = 0;
  375.   
  376. !     while(++csg->nobjs < nobjs) {
  377. !         obj = obj->next;
  378. !         hitobjp->nodes = 0;
  379. !         distobj = FAR_AWAY;
  380. !         if (!intersect(obj, ray, hitobjp, mindist, &distobj)) {
  381. !             if (operator == CSG_INTERSECT) {
  382. !                 csg->nobjs = nobjs;
  383. !                 return FALSE;
  384. !             }
  385. !             if (hitcsgp->nodes == 0)
  386. !                 continue;
  387. !         }
  388. ! 
  389. ! 
  390. !         /*
  391. !          * Call appropriate intersection method.  If FALSE is return,
  392. !          * no hit of any kind was found.
  393. !          */
  394. !         if (!(*csg->intmeth)(csg, ray, hitcsgp, hitobjp, distcsg, distobj,
  395. !             &hitclose, &distclose) || distclose > *maxdist) {
  396. !             if (operator != CSG_UNION) {
  397. !                 csg->nobjs = nobjs;
  398. !                 return FALSE;
  399. !             }
  400. !             hitcsgp->nodes = 0;
  401. !             distcsg = FAR_AWAY;
  402. !             continue;
  403. !         }
  404. ! 
  405. !         /*
  406. !          * At this time, the closest hit is in hitclose and
  407. !          * distclose.
  408. !          */
  409. !         distcsg = distclose;
  410. !         hitcsgp = hitclose;
  411. !         if (hitcsgp == &hit1)
  412. !             hitobjp = &hit2;
  413. !         else
  414. !             hitobjp = &hit1;
  415. !     }
  416. !     if (hitcsgp->nodes == 0 || distcsg < mindist || distcsg > *maxdist)
  417.           return FALSE;
  418.   
  419. !     CsgHitlistCopy(hitcsgp, hitlist);
  420. !     *maxdist = distcsg;
  421.       return TRUE;
  422.   }
  423.   
  424. ***************
  425. *** 355,387 ****
  426.   Csg *csg;
  427.   Float bounds[2][3];
  428.   {
  429. !     GeomComputeBounds(csg->obj1);
  430. !     GeomComputeBounds(csg->obj2);
  431.   
  432.       switch (csg->operator) {
  433.       case CSG_UNION:
  434. !         bounds[LOW][X] = min(csg->obj1->bounds[LOW][X], csg->obj2->bounds[LOW][X]);
  435. !         bounds[HIGH][X] = max(csg->obj1->bounds[HIGH][X], csg->obj2->bounds[HIGH][X]);
  436. !         bounds[LOW][Y] = min(csg->obj1->bounds[LOW][Y], csg->obj2->bounds[LOW][Y]);
  437. !         bounds[HIGH][Y] = max(csg->obj1->bounds[HIGH][Y], csg->obj2->bounds[HIGH][Y]);
  438. !         bounds[LOW][Z] = min(csg->obj1->bounds[LOW][Z], csg->obj2->bounds[LOW][Z]);
  439. !         bounds[HIGH][Z] = max(csg->obj1->bounds[HIGH][Z], csg->obj2->bounds[HIGH][Z]);
  440.           break;
  441.       case CSG_INTERSECT:
  442. !         bounds[LOW][X] = max(csg->obj1->bounds[LOW][X], csg->obj2->bounds[LOW][X]);
  443. !         bounds[HIGH][X] = min(csg->obj1->bounds[HIGH][X], csg->obj2->bounds[HIGH][X]);
  444. !         bounds[LOW][Y] = max(csg->obj1->bounds[LOW][Y], csg->obj2->bounds[LOW][Y]);
  445. !         bounds[HIGH][Y] = min(csg->obj1->bounds[HIGH][Y], csg->obj2->bounds[HIGH][Y]);
  446. !         bounds[LOW][Z] = max(csg->obj1->bounds[LOW][Z], csg->obj2->bounds[LOW][Z]);
  447. !         bounds[HIGH][Z] = min(csg->obj1->bounds[HIGH][Z], csg->obj2->bounds[HIGH][Z]);
  448.           break;
  449.       case CSG_DIFFERENCE:
  450. -         bounds[LOW][X] = csg->obj1->bounds[LOW][X];
  451. -         bounds[HIGH][X] = csg->obj1->bounds[HIGH][X];
  452. -         bounds[LOW][Y] = csg->obj1->bounds[LOW][Y];
  453. -         bounds[HIGH][Y] = csg->obj1->bounds[HIGH][Y];
  454. -         bounds[LOW][Z] = csg->obj1->bounds[LOW][Z];
  455. -         bounds[HIGH][Z] = csg->obj1->bounds[HIGH][Z];
  456.           break;
  457.       default:
  458.           RLerror(RL_ABORT, "Unknown csg operator type %d?\n",
  459. --- 398,438 ----
  460.   Csg *csg;
  461.   Float bounds[2][3];
  462.   {
  463. !     Geom *obj;
  464.   
  465. +     for (obj = csg->list; obj; obj = obj->next)
  466. +         GeomComputeBounds(obj);
  467. +   
  468. +     obj = csg->list;
  469. +     bounds[LOW][X]  = obj->bounds[LOW][X];
  470. +     bounds[HIGH][X] = obj->bounds[HIGH][X];
  471. +     bounds[LOW][Y]  = obj->bounds[LOW][Y];
  472. +     bounds[HIGH][Y] = obj->bounds[HIGH][Y];
  473. +     bounds[LOW][Z]  = obj->bounds[LOW][Z];
  474. +     bounds[HIGH][Z] = obj->bounds[HIGH][Z];
  475. + 
  476.       switch (csg->operator) {
  477.       case CSG_UNION:
  478. !         while (obj = obj->next) {
  479. !             bounds[LOW][X]  = min(bounds[LOW][X],  obj->bounds[LOW][X]);
  480. !             bounds[HIGH][X] = max(bounds[HIGH][X], obj->bounds[HIGH][X]);
  481. !             bounds[LOW][Y]  = min(bounds[LOW][Y],  obj->bounds[LOW][Y]);
  482. !             bounds[HIGH][Y] = max(bounds[HIGH][Y], obj->bounds[HIGH][Y]);
  483. !             bounds[LOW][Z]  = min(bounds[LOW][Z],  obj->bounds[LOW][Z]);
  484. !             bounds[HIGH][Z] = max(bounds[HIGH][Z], obj->bounds[HIGH][Z]);
  485. !         }
  486.           break;
  487.       case CSG_INTERSECT:
  488. !         while (obj = obj->next) {
  489. !             bounds[LOW][X]  = max(bounds[LOW][X],  obj->bounds[LOW][X]);
  490. !             bounds[HIGH][X] = min(bounds[HIGH][X], obj->bounds[HIGH][X]);
  491. !             bounds[LOW][Y]  = max(bounds[LOW][Y],  obj->bounds[LOW][Y]);
  492. !             bounds[HIGH][Y] = min(bounds[HIGH][Y], obj->bounds[HIGH][Y]);
  493. !             bounds[LOW][Z]  = max(bounds[LOW][Z],  obj->bounds[LOW][Z]);
  494. !             bounds[HIGH][Z] = min(bounds[HIGH][Z], obj->bounds[HIGH][Z]);
  495. !         }
  496.           break;
  497.       case CSG_DIFFERENCE:
  498.           break;
  499.       default:
  500.           RLerror(RL_ABORT, "Unknown csg operator type %d?\n",
  501. ***************
  502. *** 424,454 ****
  503.   Geom *list;
  504.   {
  505.       static int OpenAdvised = FALSE;
  506. !     /*
  507. !      * Currently, this only handles two objects.
  508. !      * Will be fixed in the future.
  509. !      * No really we promise.
  510. !      */
  511. !     if (!list || !list->next) {
  512. !         RLerror(RL_WARN, "CSG needs at least two objects.\n");
  513.           return 0;
  514.       }
  515. !     if (list->next->next) {
  516. !         RLerror(RL_WARN, "Currently, CSG only handles two objects.\n");
  517. !         return 0;
  518.       }
  519.       /*
  520.        * Things are put into lists backwards....
  521.        */
  522. !     csg->obj2 = list;
  523. !     csg->obj1 = list->next;
  524. !     if ((!csg->obj1->methods->closed || !csg->obj2->methods->closed) &&
  525. !         !OpenAdvised) {
  526. !         RLerror(RL_ADVISE,
  527. !             "Performing CSG with non-closed object(s).\n");
  528. !         OpenAdvised = TRUE;
  529.       }
  530. !     return csg->obj1->prims + csg->obj2->prims;
  531.   }
  532.   
  533.   void
  534. --- 475,517 ----
  535.   Geom *list;
  536.   {
  537.       static int OpenAdvised = FALSE;
  538. !     Geom *obj, *prev;
  539. !     int prims = 0;
  540. !      int nobjs = 0;
  541. ! 
  542. !     if (!list) {
  543. !         RLerror(RL_WARN, "CSG needs at least one object.\n");
  544.           return 0;
  545.       }
  546. !     if (!list->next) {
  547. !         RLerror(RL_WARN, "CSG with only one object.\n");
  548.       }
  549. +     prev = (Geom *)0;
  550. +     for (obj = list; ; obj = obj->next) {
  551. +         if ((!obj->methods->closed) &&
  552. +             !OpenAdvised) {
  553. +             RLerror(RL_ADVISE,
  554. +                 "Performing CSG with non-closed object(s).\n");
  555. +             OpenAdvised = TRUE;
  556. +         }
  557. +         prims += obj->prims;
  558. +         nobjs++;
  559. +         if (!obj->next)
  560. +             break;
  561. +         prev = obj;
  562. +     }
  563.       /*
  564.        * Things are put into lists backwards....
  565. +      * To make the Difference methode work, we move the last
  566. +          * element of the list to the head.
  567.        */
  568. !     csg->list = obj;
  569. !     if (prev) {
  570. !         prev->next = 0;
  571. !         obj->next = list;
  572.       }
  573. !     csg->nobjs = nobjs;
  574. !     return prims;
  575.   }
  576.   
  577.   void
  578.